// 等待DOM加载完成
document.addEventListener('DOMContentLoaded', function() {
    // 首先检查用户登录状态
    checkLoginStatus();
    
    // 获取页面元素
    const logoutBtn = document.getElementById('logoutBtn');
    const greeting = document.getElementById('greeting');
    const profileUsername = document.getElementById('profileUsername');
    const profileRegDate = document.getElementById('profileRegDate');
    const profileLastLogin = document.getElementById('profileLastLogin');
    const settingsForm = document.getElementById('settingsForm');
    const settingsMessage = document.getElementById('settingsMessage');
    const questionInput = document.getElementById('questionInput');
    const sendQuestionBtn = document.getElementById('sendQuestionBtn');
    const chatHistory = document.getElementById('chatHistory');
    const chatMessage = document.getElementById('chatMessage');
    const fileUpload = document.getElementById('fileUpload');
    
    // 如果用户已登录，加载用户信息
    const currentUser = JSON.parse(localStorage.getItem('currentUser'));
    if (currentUser) {
        loadUserInfo(currentUser);
    }
    
    // 为退出登录按钮添加点击事件
    if (logoutBtn) {
        logoutBtn.addEventListener('click', function() {
            logout();
        });
    }
    
    // 为设置表单添加提交事件
    if (settingsForm && settingsMessage) {
        settingsForm.addEventListener('submit', function(e) {
            e.preventDefault();
            saveSettings();
        });
    }
    
    // 为发送问题按钮添加点击事件
    if (sendQuestionBtn && questionInput && chatHistory) {
        sendQuestionBtn.addEventListener('click', function() {
            sendQuestion();
        });
    }
    
    // 添加键盘事件支持（回车发送）
    if (questionInput) {
        questionInput.addEventListener('keypress', function(e) {
            if (e.key === 'Enter') {
                sendQuestion();
            }
        });
    }
    
    // 加载之前的聊天历史
    loadChatHistory();
    
    // 为文件上传添加事件监听器
    if (fileUpload) {
        fileUpload.addEventListener('change', function(e) {
            handleFileUpload(e);
        });
    }
    
    // 检查用户登录状态
    function checkLoginStatus() {
        const currentUser = localStorage.getItem('currentUser');
        if (!currentUser && window.location.pathname.endsWith('main.html')) {
            // 如果用户未登录，则重定向到登录页面
            window.location.href = 'index.html';
        }
    }
    
    // 加载用户信息
    function loadUserInfo(user) {
        if (greeting) {
            greeting.textContent = `您好，${user.username}！欢迎回到您的个人中心。`;
        }
        
        if (profileUsername) {
            profileUsername.textContent = user.username;
        }
        
        // 由于我们在本地存储中没有保存注册时间和登录时间，这里使用当前时间作为示例
        const now = new Date();
        const formattedDate = now.toLocaleDateString() + ' ' + now.toLocaleTimeString();
        
        if (profileRegDate) {
            // 在实际应用中，注册时间应该保存在用户数据中
            profileRegDate.textContent = formattedDate;
        }
        
        if (profileLastLogin) {
            // 在实际应用中，上次登录时间应该保存在用户数据中
            profileLastLogin.textContent = formattedDate;
        }
    }
    
    // 退出登录函数
    function logout() {
        // 清除当前用户的登录状态
        localStorage.removeItem('currentUser');
        
        // 重定向到登录页面
        window.location.href = 'index.html';
    }
    
    // 保存设置函数
    function saveSettings() {
        const newPassword = document.getElementById('newPassword').value;
        const confirmNewPassword = document.getElementById('confirmNewPassword').value;
        
        // 如果两个密码字段都为空，则不修改密码
        if (!newPassword && !confirmNewPassword) {
            showSettingsMessage('设置已保存', 'success');
            return;
        }
        
        // 验证密码
        if (newPassword !== confirmNewPassword) {
            showSettingsMessage('两次输入的密码不一致', 'error');
            return;
        }
        
        if (newPassword.length > 0 && newPassword.length < 6) {
            showSettingsMessage('密码长度至少为6位', 'error');
            return;
        }
        
        // 获取当前用户和所有用户数据
        const currentUser = JSON.parse(localStorage.getItem('currentUser'));
        const users = JSON.parse(localStorage.getItem('users')) || [];
        
        // 更新当前用户的密码
        const updatedUsers = users.map(user => {
            if (user.username === currentUser.username) {
                return { ...user, password: newPassword };
            }
            return user;
        });
        
        // 保存更新后的用户数据
        localStorage.setItem('users', JSON.stringify(updatedUsers));
        
        // 更新当前用户的密码
        currentUser.password = newPassword;
        localStorage.setItem('currentUser', JSON.stringify(currentUser));
        
        showSettingsMessage('密码已更新', 'success');
        
        // 重置表单
        settingsForm.reset();
    }
    
    // 显示设置消息的函数
    function showSettingsMessage(message, type) {
        settingsMessage.textContent = message;
        settingsMessage.className = type;
        settingsMessage.style.display = 'block';
        
        // 3秒后自动隐藏消息
        setTimeout(function() {
            settingsMessage.style.display = 'none';
        }, 3000);
    }
    
    // 发送问题函数
    function sendQuestion() {
        const question = questionInput.value.trim();
        
        if (!question) {
            showChatMessage('请输入问题', 'error');
            return;
        }
        
        // 显示用户的问题
        addMessageToHistory('user', question);
        
        // 清空输入框
        questionInput.value = '';
        
        // 显示正在处理的消息
        showChatMessage('正在获取答案...', 'info');
        
        // 调用后端API获取真实的DeepSeek回答
        fetch('http://localhost:1234/api/chat/message', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            },
            body: JSON.stringify({
                sender: 'user',
                content: question,
                isFile: false
            })
        })
        .then(response => {
            if (!response.ok) {
                // 如果API调用失败，使用备用的模拟回答
                console.warn('API调用失败，使用备用回答');
                return { content: generateMockAnswer(question) };
            }
            return response.json();
        })
        .then(data => {
            // 显示AI的回答
            addMessageToHistory('ai', data.content);
            
            // 隐藏处理中的消息
            chatMessage.style.display = 'none';
        })
        .catch(error => {
            console.error('Error:', error);
            // 即使在捕获到异常时，也使用备用回答
            addMessageToHistory('ai', generateMockAnswer(question));
            showChatMessage('使用备用回答', 'info');
            
            // 3秒后隐藏消息
            setTimeout(function() {
                chatMessage.style.display = 'none';
            }, 3000);
        });
    }
    
    // 生成模拟答案的函数
    // 生成模拟答案的函数（备用，当API调用失败时使用）
    function generateMockAnswer(question) {
        // 现在这里作为备用选项，当API调用失败时使用
        const mockAnswers = {
            '你好': '您好！我是DeepSeek智能助手，很高兴为您服务。请问有什么可以帮助您的？',
            '今天天气怎么样': '很抱歉，我目前无法获取实时天气信息。您可以尝试询问其他问题。',
            '你能做什么': '我可以回答各种问题，提供信息咨询，帮助解决问题。请问您有什么具体需求？',
            '如何使用这个网站': '这个网站提供了用户注册、登录和个人中心功能。您可以在控制台查看活动，在个人资料查看信息，在设置中修改密码，还可以通过智能问答助手获取帮助。'
        };
        
        // 如果有匹配的预设回答，则返回该回答，否则返回通用回答
        const lowerQuestion = question.toLowerCase();
        for (const key in mockAnswers) {
            if (lowerQuestion.includes(key)) {
                return mockAnswers[key];
            }
        }
        
        return `感谢您的问题。由于这是演示版本，我无法提供完整的DeepSeek回答能力。\n\n您的问题：${question}\n\n在实际应用中，这里将显示来自DeepSeek API的真实回答。`;
    }
    
    // 添加消息到聊天历史
    function addMessageToHistory(sender, content, isFile = false, fileInfo = null) {
        const messageDiv = document.createElement('div');
        messageDiv.className = `chat-message ${sender}`;
        
        if (isFile && fileInfo) {
            // 文件消息
            const fileDiv = document.createElement('div');
            fileDiv.className = 'file-message';
            
            const fileNameSpan = document.createElement('span');
            fileNameSpan.className = 'file-name';
            fileNameSpan.textContent = fileInfo.name;
            
            const fileSizeSpan = document.createElement('span');
            fileSizeSpan.className = 'file-size';
            fileSizeSpan.textContent = `(${formatFileSize(fileInfo.size)})`;
            
            const fileIconSpan = document.createElement('span');
            fileIconSpan.className = 'file-icon';
            fileIconSpan.textContent = '📄';
            
            fileDiv.appendChild(fileIconSpan);
            fileDiv.appendChild(fileNameSpan);
            fileDiv.appendChild(fileSizeSpan);
            
            // 如果是用户发送的文件，可以添加一个查看按钮
            if (sender === 'user') {
                const viewButton = document.createElement('button');
                viewButton.className = 'view-file-btn';
                viewButton.textContent = '预览';
                viewButton.addEventListener('click', function() {
                    // 在新窗口中打开文件URL
                    window.open(fileInfo.url, '_blank');
                });
                fileDiv.appendChild(viewButton);
            }
            
            messageDiv.appendChild(fileDiv);
        } else {
            // 文本消息
            const contentDiv = document.createElement('div');
            contentDiv.className = 'message-content';
            contentDiv.textContent = content;
            
            messageDiv.appendChild(contentDiv);
        }
        
        chatHistory.appendChild(messageDiv);
        
        // 保存聊天历史
        saveChatHistory();
        
        // 滚动到底部
        chatHistory.scrollTop = chatHistory.scrollHeight;
    }
    
    // 处理文件上传
    function handleFileUpload(event) {
        const file = event.target.files[0];
        
        if (!file) return;
        
        // 验证文件类型
        if (file.type !== 'application/pdf' && !file.name.endsWith('.pdf')) {
            showChatMessage('请上传PDF格式的文件', 'error');
            // 重置文件输入
            fileUpload.value = '';
            return;
        }
        
        // 验证文件大小（限制5MB）
        const maxSize = 5 * 1024 * 1024; // 5MB
        if (file.size > maxSize) {
            showChatMessage('文件大小不能超过5MB', 'error');
            // 重置文件输入
            fileUpload.value = '';
            return;
        }
        
        // 显示上传中消息
        showChatMessage('正在上传文件...', 'info');
        
        // 创建文件URL用于预览
        const fileURL = URL.createObjectURL(file);
        
        // 显示文件信息
        const fileInfo = {
            name: file.name,
            size: file.size,
            type: file.type,
            url: fileURL
        };
        
        // 添加文件到聊天历史
        addMessageToHistory('user', '', true, fileInfo);
        
        // 创建FormData对象
        const formData = new FormData();
        formData.append('file', file);
        
        // 调用后端API处理文件
        fetch('http://localhost:1234/api/chat/file', {
            method: 'POST',
            body: formData
        })
        .then(response => {
            if (!response.ok) {
                // 如果API调用失败，使用备用的模拟回答
                console.warn('API调用失败，使用备用回答');
                return { content: generateMockFileAnswer(file.name) };
            }
            return response.json();
        })
        .then(data => {
            // 显示正在处理的消息
            showChatMessage('正在分析文件内容...', 'info');
            
            // 显示AI的回答
            setTimeout(function() {
                addMessageToHistory('ai', data.content);
                
                // 隐藏处理中的消息
                chatMessage.style.display = 'none';
                
                // 重置文件输入
                fileUpload.value = '';
            }, 1000);
        })
        .catch(error => {
            console.error('Error:', error);
            // 即使在捕获到异常时，也使用备用回答
            addMessageToHistory('ai', generateMockFileAnswer(file.name));
            showChatMessage('使用备用文件分析回答', 'info');
            
            // 3秒后隐藏消息
            setTimeout(function() {
                chatMessage.style.display = 'none';
            }, 3000);
            
            // 重置文件输入
            fileUpload.value = '';
        });
    }
    
    // 生成模拟的文件回答（备用，当API调用失败时使用）
    function generateMockFileAnswer(fileName) {
        return `您已上传文件：${fileName}\n\n这是备用回答，建议检查API连接。`;
    }
    
    // 格式化文件大小
    function formatFileSize(bytes) {
        if (bytes === 0) return '0 Bytes';
        
        const k = 1024;
        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
        const i = Math.floor(Math.log(bytes) / Math.log(k));
        
        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
    }
    
    // 保存聊天历史
    function saveChatHistory() {
        const currentUser = JSON.parse(localStorage.getItem('currentUser'));
        if (!currentUser) return;
        
        const messages = [];
        document.querySelectorAll('#chatHistory .chat-message').forEach(message => {
            const sender = message.classList.contains('user') ? 'user' : 'ai';
            
            // 检查是否是文件消息
            const fileMessage = message.querySelector('.file-message');
            if (fileMessage) {
                const fileName = fileMessage.querySelector('.file-name')?.textContent || '';
                const fileSizeText = fileMessage.querySelector('.file-size')?.textContent || '';
                const fileSize = extractFileSize(fileSizeText);
                
                messages.push({
                    sender,
                    content: '',
                    isFile: true,
                    fileInfo: {
                        name: fileName,
                        size: fileSize,
                        type: 'application/pdf'
                    },
                    timestamp: new Date().toISOString()
                });
            } else {
                // 文本消息
                const content = message.querySelector('.message-content')?.textContent || '';
                messages.push({ sender, content, isFile: false, timestamp: new Date().toISOString() });
            }
        });
        
        localStorage.setItem(`chat_${currentUser.username}`, JSON.stringify(messages));
    }
    
    // 从文件大小文本中提取字节数
    function extractFileSize(sizeText) {
        // 这个函数只是简单处理，实际应用中可能需要更复杂的解析
        // 例如从 "(2.5 MB)" 中提取 2.5 和 "MB"，然后转换为字节数
        return 0; // 简化处理，实际应用中应该正确解析
    }
    
    // 加载聊天历史
    function loadChatHistory() {
        const currentUser = JSON.parse(localStorage.getItem('currentUser'));
        if (!currentUser) return;
        
        const messages = JSON.parse(localStorage.getItem(`chat_${currentUser.username}`)) || [];
        
        messages.forEach(message => {
            if (message.isFile && message.fileInfo) {
                // 对于文件消息，我们不能直接恢复文件URL，因为它是临时的
                // 但我们可以显示文件信息，让用户知道他们曾经发送过这个文件
                addMessageToHistory(message.sender, '', true, {
                    name: message.fileInfo.name,
                    size: message.fileInfo.size,
                    type: message.fileInfo.type,
                    url: null // 不恢复实际的文件URL，因为它是临时的
                });
            } else {
                // 文本消息
                addMessageToHistory(message.sender, message.content);
            }
        });
    }
    
    // 显示聊天消息的函数
    function showChatMessage(message, type) {
        if (chatMessage) {
            chatMessage.textContent = message;
            chatMessage.className = type;
            chatMessage.style.display = 'block';
        }
    }
    
    // 添加平滑滚动效果
    document.querySelectorAll('a[href^="#"]').forEach(anchor => {
        anchor.addEventListener('click', function (e) {
            e.preventDefault();
            
            document.querySelector(this.getAttribute('href')).scrollIntoView({
                behavior: 'smooth'
            });
        });
    });
});